pretty-quick

What is pretty-quick?

The pretty-quick npm package is a tool that runs Prettier, an opinionated code formatter, on your changed files. It integrates with version control systems like Git to format only the files that have been modified. This can be particularly useful as a pre-commit hook to ensure code style consistency without having to format the entire codebase on every commit.

What are pretty-quick's main functionalities?

Running on Changed Files

Run Prettier on all files that have changed since the last commit. This is the basic usage and can be integrated into pre-commit hooks.

npx pretty-quick

Running with Specific Options

Run Prettier on all changed files but filter them by a specific pattern. In this case, only JavaScript files will be formatted.

npx pretty-quick --pattern "**/*.js"

Staging Changes

Run Prettier on all staged files and re-stage the changes automatically. This is useful for ensuring that only formatted code gets committed.

npx pretty-quick --staged

Other packages similar to pretty-quick

husky

Husky is a tool for managing Git hooks. It allows you to run scripts at various points in the Git lifecycle, such as pre-commit or pre-push. While it doesn't format code by itself, it is often used in conjunction with tools like Prettier or pretty-quick to enforce code style by running them as pre-commit hooks.

lint-staged

Lint-staged is similar to pretty-quick in that it runs linters on staged files in Git. It is more flexible than pretty-quick because it can run any command, not just Prettier, and it can be configured to run different commands for different file types.

prettier

Prettier itself is the underlying code formatter that pretty-quick leverages. While pretty-quick focuses on running Prettier only on changed files, Prettier can be used to format entire codebases or individual files, regardless of their version control status.

README

pretty-quick

Get Pretty Quick

Runs Prettier on your changed files.

Supported source control managers:

• Git
• Mercurial

Install

With yarn:

yarn add --dev prettier pretty-quick

With npm:

npm install --save-dev prettier pretty-quick

Usage

With yarn:

yarn pretty-quick

With npx:

npx pretty-quick

With npm:

1. Add "pretty-quick": "pretty-quick" to the scripts section of package.json.
2. npm run pretty-quick

Pre-Commit Hook

You can run pretty-quick as a pre-commit hook using husky.

For Mercurial have a look at husky-hg

yarn add --dev husky

In package.json, add:

"husky": {
  "hooks": {
    "pre-commit": "pretty-quick --staged"
  }
}

CLI Flags

--staged (only git)

Pre-commit mode. Under this flag only staged files will be formatted, and they will be re-staged after formatting.

Partially staged files will not be re-staged after formatting and pretty-quick will exit with a non-zero exit code. The intent is to abort the git commit and allow the user to amend their selective staging to include formatting fixes.

--no-restage (only git)

Use with the --staged flag to skip re-staging files after formatting.

--branch

When not in staged pre-commit mode, use this flag to compare changes with the specified branch. Defaults to master (git) / default (hg) branch.

--pattern

Filters the files for the given minimatch pattern.
For example pretty-quick --pattern "**/*.*(js|jsx)" or pretty-quick --pattern "**/*.js" --pattern "**/*.jsx"

--verbose

Outputs the name of each file right before it is proccessed. This can be useful if Prettier throws an error and you can't identify which file is causing the problem.

--bail

Prevent git commit if any files are fixed.

--check

Check that files are correctly formatted, but don't format them. This is useful on CI to verify that all changed files in the current branch were correctly formatted.

Configuration and Ignore Files

pretty-quick will respect your .prettierrc, .prettierignore, and .editorconfig files, so there's no additional setup required. Configuration files will be found by searching up the file system. .prettierignore files are only found from the repository root and the working directory that the command was executed from.